13 字符串类型内置方法

251次阅读

共计 6129 个字符，预计需要花费 16 分钟才能阅读完成。

前面 "Python 开发入门" 那一章已经对 python 基本的数据类型进行了大概的描述, 以下我们主要从其内置方法来学习

每一个数据类型都自带一个制造的 "工厂"
那么字符串类型的 "工厂" 就是 str

msg = 'abc'
🍉背后的操作就是
msg = str("abc")

str 工厂可以把所有类型转成字符串类型

x = 111
y = 2.5
z = [111,222,333]
v = {"name":"shawn"}
print(type(str(x)))  #<class 'str'>
print(type(str(y)))  #<class 'str'>
print(type(str(z)))  #<class 'str'>
print(type(str(v)))  #<class 'str'>

只能取值, 不能改值(不可变类型)

msg = 'hello world'
🍉正向取
print(msg[0])   # h
print(msg[5])   # 取到的是空格

🍉反向取
print(msg[-1])  # d

🍉如果改值就会报错
# msg[0] = 'H'  # 报错

从一个字符串中拷贝出一个子字符串

msg = 'hello world'
🍉顾头不顾尾
print(msg[0:3])   # hel
print(msg[0:5])   # hello

🍉步长
print(msg[0:8:2])   # hlow

🍉反向步长
print(msg[5:0:-1])  #  olle

🍉拷贝字符串
print(msg[:12])          # hello world
print(msg[:len(msg)])    # hello world
print(msg[0:])           # hello world
print(msg[:])            # hello world (更简洁)

🍉将字符串顺序反向
res = msg[::-1]
print(res)      # dlrow olleh

通常配合 for 循环使用, 索引取值

msg = 'hello world'
print(len(msg))  # 13

判断一个子字符在步子啊一个大字符串里面,in 不 in

msg="hello world"
🍉"in"
print("he" in msg)
print("h" in msg)

🍉"not in"
print(not 'egon' in msg)
print('egon' not in msg)  # 推荐

默认是左右两侧空格, 但可以指定符号
也可以填多个符号, 一般用于用户输入

🍉字符串左右两边有空白
name="    shawn        "
print(name.strip())  #shawn
print(name)   #"    shawn    " 原值并没有改变, 产生的是新值

🍉只去两边, 不会去掉中间的, 指定的是什么就去什么
name="** *eg*on***"
print(name.strip("*"))   # *eg*on"

🍉指定多个符号
x="*(-)=+abc=-)*/"
print(x.strip("*()-=+/"))  # ABC

🍉通常用于去掉用户手抖输入的空格
name=input("username>>>: ").strip()
pwd=input("password>>>: ").strip()
if name == "egon" and pwd == "123":
    print("ok")
else:
    print('error')

把一个有规律的字符串按照某种分隔符进行切分
并且是从左往右切, 得到的是一个列表

🍉默认切分的分隔符是空格
info = 'shawn  age 18 sex male'
res = info.split()
print(res)  # ['shawn','age', '18','sex', 'male']

🍉指定分隔符
info = 'shawn:age:18:sex:male'
res = info.split(':')
print(res)  # ['shawn','age', '18','sex', 'male']

🍉指定分隔次数
info = 'shawn  age 18 sex male'
res = info.split(':', 2)    # 1 表示从左边开始，只切分两次:
print(res)  # ['shawn','age', '18:sex:male']

循环取出子字符

msg="hello"
for i in msg:
    print(i)

strip : 移除字符串左右两侧的符号
lstrip : 移除字符串左侧的符号
rstrip : 移除字符串右侧的符号

msg="***hello***"
print(msg.strip("*"))  #hello
print(msg.lstrip("*")) #hello***
print(msg.rstrip("*")) #***hello

lower : 将字母转化为全小写
upper : 将字母转化为全大写

msg="HeLlo"
print(msg.lower())  #hello
print(msg.upper())  #HELLO
print(msg)          #HeLlo (原值不变)

startswith : 判断是否以给定的字符串开始
endswith : 判断是否以给定的字符串结束

msg="hello word"
print(msg.startswith("he"))     #True
print(msg.startswith("hello"))  #True
print(msg.endswith("rd"))       #True

字符串格式化的三种方式:https://www.cnblogs.com/songhaixing/p/14003315.html
以下是 .format 的三种玩法

🍉直接传变量名
res="my name is {name} my age is {age}".format(age=18,name="shawn")
print(res)  #my name is shawn my age is 18

🍉不放任何值, 让其按位置自动传值
res="my name is {} my age is {}".format(18,"shawn")
print(res)  #my name is 18 my age is shawn

🍉通过索引传值
res="my name is {0}{0}{0} my age is {1}{0}".format(18,"shawn")
print(res)  #my name is 181818 my age is shawn18

.format 的高级玩法
对齐

🍉传入值左对齐, 共占 "10" 的字符位置, 不足以 "*" 填充
res="my name is {0:*<10} my age is {1}".format(18,"shawn")
print(res)  #my name is 18******** my age is shawn

🍉传入值右对齐, 共占 "10" 的字符位置, 不足以 "*" 填充
res="my name is {0:*>10} my age is {1}".format(18,"shawn")
print(res)  #my name is ********18 my age is shawn

🍉传入值居中对齐, 共占 "10" 的字符位置, 不足以 "*" 填充
res="my name is {0:*^10} my age is {1:=^10}".format(18,"shawn")
print(res)  #my name is ****18**** my age is ==shawn===

2. 进制与精度

🍉二进制转换
res="{0:b} ".format(18)
print(res)  #10010

🍉八进制转换
res="{0:o} ".format(18)
print(res)  #22

🍉十六进制转换
res="{0:x} ".format(18)
print(res)  #12 

🍉三位一体以 "," 分隔开
res="{0:,} ".format(13333333338)
print(res)  #13,333,333,338 

🍉保留小数位(四舍五入)
res="{0:.3f} ".format(3.7777)
print(res)  #3.778

split : 把字符串按照指定的字符从左开始切成列表
rsplit : 把字符串按照指定的字符从右开始切成列表

🍉从左右两边切的次数不同, 效果就不同
info="root:123:0:0"
print(info.split(":",2))  #['root', '123', '0:0']
print(info.rsplit(":",2)) #['root:123', '0', '0']

按照指定的分隔符, 将一个列表拼接成一个大字符串
这个列表里的元素必须 全为字符串 类型

ps : 单纯的使用 "+" 拼接字符串效率太低, 因为它需要申请新的内存空间

l=["a","b","c"]
🍉"+" 方法不推荐
print(l[0]+":"+l[1]+":"+l[2])

🍉使用 ":" 拼接
res=":".join(l)
print(res)  #root:123:0:0

🍉与 "split" 相对使用
info="root:123:0:0"
l=info.split(":")
print(l)            #['root', '123', '0', '0']
print(":".join(l))  #root:123:0:0

三个参数: 第一个是原值, 第二个是新值, 第三个是指定替换的次数, 默认不指定

msg="song is song hai xing"
res=msg.replace("song","SONG",2)
print(res)  #SONG is SONG hai xing

通常用于接收用户输入个数时

print('123'.isdigit())   # True
print('12.3'.isdigit())  # False

🍉用户输入示例
age=input("your age>>").strip()
if age.isdigit():
    age=int(age)
else:
    print(" 请输入数字 ")

find : 指定子字符在大字符串中的 从左侧开始 的起始位置的索引
rfind : 指定子字符在大字符串中的 从右侧开始 的起始位置的索引
index : 指定子字符在大字符串中的 从左侧开始 的起始位置的索引
rindex : 指定子字符在大字符串中的 从右侧开始 的起始位置的索引

ps : find 找不到字符串会返回 "-1", 而 index 会报错

msg='song hai xing song hhh'
🍉find, rfind
print(msg.find('sb'))
print(msg.find('song'))
print(msg.find('song',13,20))
print(msg.rfind('song'))

🍉index, rindex
print(msg.index('song'))
print(msg.rindex('song'))
print(msg.index('sb'))  #找不到会报错，而 find 不会

msg = 'shawnnnn'
print(msg.count('n'))   # 4

.center : 居中
.ljust : 左对齐填充
.rjust : 右对齐填充
.zfill : 默认以 "0" 右填充

🍉不放符号的话，默认空格填充
print('========song========')
print('song'.center(40,'@'))
print('song'.ljust(40,'$'))
print('song'.rjust(30,'&'))  
print('song'.zfill(40))  #右对齐以 "0" 填充

msg='abc\tdfg'            #\t  指的是 Tab 键
print(msg.expandtabs(4))  #指定空格数为 4

.capitalize : 首字母为大写，其他都为小写
.swapcase : 大写换小写，小写换大写
.title : 每个单词的首字母都换成大写

print('ytdGFHGgfh'.capitalize())  #Ytdgfhggfh
print('jhkjJKHJKjkhk'.swapcase()) #JHKJjkhjkJKHK
print('song hai xing'.title())    #Song Hai Xing

num1=b'4'  #bytes
num2=u'4'  #unicode python3 中无需加 u 就是 unicode
num3=u'肆' #中文数字
num4=u'Ⅳ' #罗马数字

.isdigit(): bytes, unicode 类型的阿拉伯数字

print(num1.isdigit()) #T
print(num2.isdigit()) #T
print(num3.isdigit()) #F
print(num4.isdigit()) #F

.isdecimal(): unicode 类型的阿拉伯数字

print(num2.isdecimal()) #T
print(num3.isdecimal()) #F
print(num4.isdecimal()) #F

.isnumberic(): unicode 类型的阿拉伯 \ 中文 \ 罗马数字

print(num2.isnumeric()) #T
print(num3.isnumeric()) #T
print(num4.isnumeric()) #T

🍉判断字符是否全由字母组成
print('asdfaaAsfd'.isalpha())  #True

🍉判断字符是否由字母 或 数字组成
print('asdf'.isalnum())        #True

🍉判断首字母是否大写
print('I Am Egon'.istitle())   #True

🍉判断是否是空格
print(' '.isspace())        #True

🍉判断是否是一个有效的标识符, 数字开头就不合法
print('print'.isidentifier())  #True
print('123nt'.isidentifier())  #Flase

ps : Python 中汉字是当做字母来判断的, 加上字符编码属性可以解决

🍉纯字母
s = 'shawnHAHA'
print(a.isalpha())            # True

🍉含汉字
s = 'shawn 哈哈哈'
print(a.isalpha())           # True

🍉纯汉字
s = '哈哈哈'
print(a.isalpha())           # True

🍉加上字符编码属性
s = 'sas 哈哈哈'
print(a.encode("utf-8").isalpha())  # Flase